import ToeUpload from '@/components/UploadDialog/index';
import {
  addDriveParaLib,
  delDriveParaLib,
  updateDriveParaLib,
} from '@/services/drivepara/driveparalib';
import { uploadLicenseExcel } from '@/services/sales/license';
import { getS210motorList, getV90motorList } from '@/services/sales/salesNeedInfo';
import type { EditableFormInstance } from '@ant-design/pro-components';
import { PageHeaderWrapper } from '@ant-design/pro-layout';
import type { ActionType, ProColumns } from '@ant-design/pro-table';
import { Form, Input, message, Modal } from 'antd';
import React, { useRef, useState } from 'react';
import { PlusOutlined } from '@ant-design/icons';
import ProTable from '@ant-design/pro-table';
import Button from 'antd/es/button';

import DebounceSelect from '@/components/DebounceSelect';
import { EditableProTable } from '@ant-design/pro-table';

interface TableFormDateType {
  id: string;
  workId?: string;
  name?: string;
  department?: string;
  isNew?: boolean;
  editable?: boolean;
}

interface UserValue {
  label: string;
  value: string;
}

async function fetchV90motorList(username: string): Promise<UserValue[]> {
  console.log('fetching user', username);
  return getV90motorList({ blurry: username }).then((res) => {
    return res.data.map((item) => {
      return {
        label: item.motorOrderNum,
        value: item.motorOrderNum,
        rowData: item,
      };
    });
  });
}

async function fetchS210motorList(username: string): Promise<UserValue[]> {
  console.log('fetching user', username);
  return getS210motorList({ blurry: username }).then((res) => {
    return res.data.map((item) => {
      return {
        label: item.motorOrderNum,
        value: item.motorOrderNum,
        rowData: item,
      };
    });
  });
}

const DriveParaLib: React.FC<{}> = () => {
  const [modalVisit, setModalVisit] = useState(false); // 新建和编辑提示框
  const [deleteVisit, setDeleteVisit] = useState(false); // 删除提示框

  const [formTitle, setFormTitle] = useState('新建驱动参数库'); //
  const [rowData, setRowData] = useState({ id: '' }); // 保存行值
  const actionRef = useRef<ActionType>();
  const editorFormRef = useRef<EditableFormInstance<DataSourceType>>();
  const [isCreate, setIsCreate] = useState(false);
  const [form] = Form.useForm();
  // 表格数据
  const [dataSource, setDataSource] = useState<DataSourceType[]>([]);
  const [uploadVisit, setUploadVisit] = useState(false); //上传按钮显示
  const uploadRef = useRef(null);
  /**
   * 穿梭框的数据设置
   */
  const columns: ProColumns[] = [
    {
      title: '序号',
      dataIndex: 'index',
      valueType: 'index',
      width: 80,
    },
    {
      title: '唯一标识', //表头显示的名称
      search: false,
      hideInTable: true,
      dataIndex: 'identification', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    },
    {
      title: '行业', //表头显示的名称

      dataIndex: 'vm', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路

      valueType: 'select',
      valueEnum: {
        1: { text: '电子' },
        2: { text: '电池' },
        3: { text: '物流' },
        4: { text: '汽车' },
        5: { text: '太阳能' },
        6: { text: '增材制造' },
        7: { text: '包装' },
        8: { text: '食品饮料' },
        9: { text: '金属加工' },
        10: { text: '其他' },
      },
    },

    {
      title: '设备名称', //表头显示的名称

      dataIndex: 'deviceName', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    },

    {
      title: '轴名称', //表头显示的名称
      search: false,
      dataIndex: 'shaftName', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    },

    {
      title: '硬件标识符', //表头显示的名称
      search: false,
      dataIndex: 'hardwareidentifier', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    },

    // {
    //   title: '驱动类型', //表头显示的名称
    //   dataIndex: 'driveType', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    //   valueType: 'select',
    //   valueEnum: {
    //     1: { text: 'v90' },
    //     2: { text: 's210' },
    //   },
    // },
    {
      title: '驱动类型', //
      search: false,
      key: 'driveType',
      dataIndex: 'driveType',
      valueType: 'select',
      valueEnum: {
        1: { text: 'V90', status: 'Default' },
        2: {
          text: 'S210',
          status: 'success',
        },
        0: {
          text: '第三方',
          status: 'warning',
        },
      },
      formItemProps: {
        rules: [
          {
            required: true,
            message: '此项是必填项',
          },
        ],
      },
    },
    {
      title: '电机订货号', //
      search: false,
      dataIndex: 'motorOrderNum',
      width: 200,
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        console.log(config, '--');
        // 这个事v90
        if (config.record.driveType === '1') {
          return (
            <DebounceSelect
              // value={value}
              placeholder="v90"
              fetchOptions={fetchV90motorList}
              onChange={(newValue, rowDate) => {
                console.log(rowDate.rowData, '-----newValue---');
                const rows = editorFormRef.current?.setRowData?.(config?.recordKey, {
                  ...rowDate.rowData,
                });
                console.log(rows, '---rows---');
              }}
              style={{ width: '100%' }}
            />
          );
        } else if (config.record.driveType === '2') {
          return (
            //这个是v210
            <DebounceSelect
              // value={value}
              placeholder="s210"
              fetchOptions={fetchS210motorList}
              onChange={(newValue, rowDate) => {
                console.log(rowDate, '-----newValue---');
                const rows = editorFormRef.current?.setRowData?.(config?.recordKey, {
                  ...rowDate.rowData,
                });
                console.log(rows, '---rows---');
              }}
              style={{ width: '100%' }}
            />
          );
        } else {
          return <Input />;
        }
      },
    },
    {
      title: '电机ID', //表头显示的名称
      search: false,
      dataIndex: 'motorId', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'digit',
    },
    {
      title: '额定电流', //表头显示的名称
      search: false,
      dataIndex: 'ratedCurrent',
      valueType: 'digit',
    },
    {
      title: '额定电流', //表头显示的名称
      valueType: 'digitRange',
      dataIndex: 'ratedCurrent',
      hideInTable: true,
    },
    {
      title: '额定扭矩', //表头显示的名称
      search: false,
      dataIndex: 'ratedTorque', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'digit',
    },
    {
      title: '额定扭矩', //表头显示的名称
      valueType: 'digitRange',
      dataIndex: 'ratedTorque', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      hideInTable: true,
    },
    {
      title: '额定功率', //表头显示的名称
      search: false,
      dataIndex: 'ratedPower',
      valueType: 'digit',
    },
    {
      title: '额定功率', //表头显示的名称
      valueType: 'digitRange',
      dataIndex: 'ratedPower',
      hideInTable: true,
    },
    {
      title: '编码器', //表头显示的名称
      search: false,
      dataIndex: 'ecoderType', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        0: { text: '单圈绝对值编码器' },
        1: { text: '多圈绝对值编码器' },
        2: { text: '增量编码器' },
      },
    },
    {
      title: '抱闸', //表头显示的名称
      search: false,
      dataIndex: 'brake',
      valueType: 'select',
      valueEnum: {
        0: { text: '不带抱闸' },
        1: { text: '带抱闸' },
      },
    },
    {
      title: '额定速度', //表头显示的名称
      search: false,
      dataIndex: 'ratedSpeed', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    },
    {
      title: '额定电压', //表头显示的名称
      search: false,
      dataIndex: 'ratedVoltage',
    },
    {
      title: '电机惯量', //表头显示的名称
      search: false,
      dataIndex: 'motorInertia', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    },
    {
      title: '电机惯量', //表头显示的名称
      valueType: 'digitRange',
      dataIndex: 'motorInertia', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      hideInTable: true,
    },
    {
      title: '负载类型', //表头显示的名称

      dataIndex: 'loadType',
      valueType: 'select',
      valueEnum: {
        1: { text: '水平' },
        2: { text: '旋转' },
        3: { text: '垂直' },
        4: { text: '斜坡' },
        5: { text: '其它' },
      },
    },
    {
      title: '机械结构', //表头显示的名称

      dataIndex: 'mechanicalStructure',
      valueType: 'select',
      valueEnum: {
        1: { text: '丝杠' },
        2: { text: '齿轮齿条' },
        3: { text: '皮带轮' },
        4: { text: '圆盘' },
        5: { text: '辊式带' },
        6: { text: '链条' },
      },
    },
    {
      title: '控制模式', //表头显示的名称

      dataIndex: 'controlMode', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        1: { text: 'TO' },
        2: { text: 'Epos' },
        3: { text: 'Speed' },
      },
    },

    {
      title: '通讯报文', //表头显示的名称

      dataIndex: 'commTelegram',
      valueType: 'select',
      valueEnum: {
        1: { text: '105' },
        2: { text: '111' },
        3: { text: '102' },
        4: { text: '3' },
        5: { text: '1' },
      },
    },

    {
      title: '附加报文', //表头显示的名称
      search: false,
      dataIndex: 'additionalTelegram', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        1: { text: 'None' },
        2: { text: '750' },
      },
    },
    {
      title: '电机方向', //表头显示的名称
      search: false,
      dataIndex: 'motorRotation',
      valueType: 'select',
      valueEnum: {
        0: { text: '正向' },
        1: { text: '反向' },
      },
    },
    {
      title: '齿轮比负载(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'gearRationLoad', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    },
    {
      title: '齿轮比电机(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'gearRationMotor',
    },

    {
      title: '定位精度(V90 EPOS)', //表头显示的名称

      dataIndex: 'positionAccuracy', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        1: { text: '0.1mm' },
        2: { text: '0.01mm' },
        3: { text: '0.001mm' },
        4: { text: '0.1°' },
        5: { text: '0.01°' },
        6: { text: '0.001°' },
      },
    },
    {
      title: '负载一圈的距离(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'loadOneTurnDistance',
    },
    {
      title: '软限位激活(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'softLimitActive', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        1: { text: 'Yes' },
        2: { text: 'No' },
      },
    },
    {
      title: '软限位(正)(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'softLimitPositive',
    },

    {
      title: '软限位(负)(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'softLimitNegative', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    },
    {
      title: '0-Vmax时间(V90 EPOS)', //表头显示的名称

      dataIndex: 'increaseTimeEpos',
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: ':0.5-1.0' },
        6: { text: '1.0-2.0,°' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
    },
    {
      title: 'Vmax-0时间(V90 EPOS)', //表头显示的名称

      dataIndex: 'decreaseTimeEpos', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: ':0.5-1.0' },
        6: { text: '1.0-2.0,°' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
    },
    {
      title: '模态轴是否激活(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'modualActiveEpos',
      valueType: 'select',
      valueEnum: {
        1: { text: 'Yes' },
        2: { text: 'No' },
      },
    },

    {
      title: '模态长度(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'modualLengthEpos', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    },
    {
      title: 'DI1(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'di1Epos',
      valueType: 'select',
      valueEnum: {
        0: { text: 'None' },
        3: { text: '正限位' },
        4: { text: '负限位' },
        2: { text: '复位' },
        24: { text: '回零开关' },
      },
    },
    {
      title: 'DI2(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'di2Epos', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        0: { text: 'None' },
        3: { text: '正限位' },
        4: { text: '负限位' },
        2: { text: '复位' },
        24: { text: '回零开关' },
      },
    },
    {
      title: 'DI3(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'di3Epos',
      valueType: 'select',
      valueEnum: {
        0: { text: 'None' },
        3: { text: '正限位' },
        4: { text: '负限位' },
        2: { text: '复位' },
        24: { text: '回零开关' },
      },
    },

    {
      title: 'DO1(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'do1Epos', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        0: { text: 'None' },
        3: { text: '正限位' },
        4: { text: '负限位' },
        2: { text: '复位' },
        24: { text: '回零开关' },
      },
    },
    {
      title: '0-Vmax时间(V90TO/S210)', //表头显示的名称

      dataIndex: 'increaseTimeTO',
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: ':0.5-1.0' },
        6: { text: '1.0-2.0,°' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
    },
    {
      title: 'Vmax-0时间(V90TO/S210)', //表头显示的名称

      dataIndex: 'decreaseTimeTO', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: ':0.5-1.0' },
        6: { text: '1.0-2.0,°' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
    },
    {
      title: '0-nmax时间(V90Speed)', //表头显示的名称

      dataIndex: 'increaseTimeSpeed',
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: ':0.5-1.0' },
        6: { text: '1.0-2.0,°' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
    },
    {
      title: 'nmax-0时间(V90Speed)', //表头显示的名称

      dataIndex: 'decreaseTimeSpeed',
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: ':0.5-1.0' },
        6: { text: '1.0-2.0,°' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
    },

    {
      title: '速度环增益(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'kpEpos',
    },
    {
      title: '速度环积分(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'tnEpos', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    },
    {
      title: '位置环增益(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'kprEpos',
    },
    {
      title: '速度环前馈系数(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'coeffVelEpos',
    },
    {
      title: '机械齿轮每圈LU(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'luLoopEpos',
    },
    {
      title: '最大速度(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'vmaxEpos', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    },
    {
      title: '最大加速度(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'accmaxEpos',
    },
    {
      title: '最大减速度(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'dccmaxEpos',
    },

    {
      title: 'Jerk(V90 EPOS)', //表头显示的名称
      search: false,
      dataIndex: 'jerkEpos',
    },
    {
      title: '速度环Kp(V90Speed)', //表头显示的名称
      search: false,
      dataIndex: 'kpSpeed', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    },
    {
      title: '速度环Tn(V90Speed)', //表头显示的名称
      search: false,
      dataIndex: 'tnSpeed',
    },
    {
      title: '斜坡上升t(V90Speed)', //表头显示的名称
      search: false,
      dataIndex: 'tincSpeed',
    },

    {
      title: '斜坡下降t(V90Speed)', //表头显示的名称
      search: false,
      dataIndex: 'tdecSpeed',
    },
    {
      title: '斜坡圆弧起始t(V90Speed)', //表头显示的名称
      search: false,
      dataIndex: 'tstartSpeed', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    },
    {
      title: '斜坡圆弧结束t(V90Speed)', //表头显示的名称
      search: false,
      dataIndex: 'tstopSpeed',
    },
    {
      title: '速度环Kp(V90TO/S210)', //表头显示的名称
      search: false,
      dataIndex: 'kpTO',
    },
    {
      title: '速度环Tn(V90TO/S210)', //表头显示的名称
      search: false,
      dataIndex: 'tnTO', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
    },
    // {
    //   title: '创建者', //表头显示的名称
    //   search: false,
    //   dataIndex: 'createBy',
    // },
    // {
    //   title: '创建时间', //表头显示的名称
    //   search: false,
    //   dataIndex: 'createTime',
    // },

    {
      title: '操作',
      valueType: 'option',
      key: 'option',
      fixed: 'right',
      render: (text, record, _, action) => [
        <a
          key="editable"
          onClick={() => {
            action?.startEditable?.(record.id);
          }}
        >
          编辑
        </a>,
        <a
          key="delete"
          onClick={() => {
            setDataSource(dataSource.filter((item) => item.id !== record.id));
          }}
        >
          删除
        </a>,
        <EditableProTable.RecordCreator
          key="copy"
          record={{
            ...record,
            id: (Math.random() * 1000000).toFixed(0),
          }}
        >
          <a>复制</a>
        </EditableProTable.RecordCreator>,
      ],
    },
  ];

  const handleSubmit = async () => {
    if (formTitle == '新建驱动参数库') {
      await addDriveParaLib(form.getFieldsValue());
    } else {
      await updateDriveParaLib(form.getFieldsValue());
    }

    message.success('添加成功');
    setModalVisit(false);
    // 这个爆红不用管(从新加载页面)
    actionRef.current.reload();
  };
  return (
    <PageHeaderWrapper title={false} breadcrumb={undefined}>
      <ProTable //表格Pro组件
        headerTitle="驱动参数库" //表头
        actionRef={actionRef} //用于触发刷新操作等，看api
        rowKey="id" //表格行 key 的取值，可以是字符串或一个函数
        FormRef={editorFormRef}
        scroll={{ x: 6000 }}
        editable={{
          type: 'multiple',
          onSave: async (rowKey, row) => {
            console.log(row);
            delete row.index;
            if (isCreate) {
              delete row.title;
              delete row.id;
              await addDriveparaLib(row);
            } else {
              await updateDriveparaLib(row);
            }

            actionRef.current.reload();
          },
        }}
        columnsState={{
          persistenceKey: 'pro-table-singe-demos',
          persistenceType: 'localStorage',
          onChange(value) {
            console.log('value: ', value);
          },
        }}
        search={{
          labelWidth: 150,
          span: 6,
        }}
        options={{
          setting: {
            listsHeight: 400,
          },
        }}
        pagination={{
          pageSize: 5,
          onChange: (page) => console.log(page),
        }}
        dateFormatter="string"
        toolBarRender={() => [
          <Button
            key="button"
            icon={<PlusOutlined />}
            onClick={() => {
              actionRef.current?.addEditRecord?.({
                id: (Math.random() * 1000000).toFixed(0),
                title: '新的一行',
              });
              setIsCreate(true);
            }}
            type="primary"
          >
            新建
          </Button>,

          <Button
            key="button"
            icon={<PlusOutlined />}
            onClick={() => {
              // console.log(selectedRows, '---选取多行----');
              // 1.清空form
              setUploadVisit(true);
            }}
            type="primary"
          >
            导入
          </Button>,
          <Button
            key="button"
            icon={<PlusOutlined />}
            onClick={() => {
              // console.log(selectedRows, '---选取多行----');
              // 1.清空form
              licenseExcelExport().then((res) => {
                const aLink = document.createElement('a');
                document.body.appendChild(aLink);
                aLink.style.display = 'none';
                aLink.href = window.URL.createObjectURL(res);
                aLink.setAttribute('download', `授权号${new Date()}.xlsx`);
                aLink.click();
                document.body.removeChild(aLink);
              });
            }}
            type="primary"
          >
            导出
          </Button>,
        ]}
        request={async (params = {}, sort, filter) => {
          console.log(params, sort, filter);
          const result = await getDriveparaLibByPage(params);
          console.log(result);
          return {
            data: result.data.content,
            total: result.data.totalElements,
            success: result.success,
          };
          // return  await new Promise({data:[{loginName:}], total:10, success: 0})
          // return {data:[], total:10, success: 0}
        }} //请求数据的地方，例子是用mock模拟数据，我是在后台请求的数据
        columns={columns} //上面定义的
        rowSelection={{}}
      />
      {/* <EditableProTable<TableFormDateType>
        value={dataSource}
        editableFormRef={editorFormRef}
        scroll={{ x: 4000 }}
        // editable={{
        //   type: 'multiple',
        //   onChange: (rowKey, row) => {
        //     console.log(rowKey, row, '--rowKey---');
        //   },
        // }}
        recordCreatorProps={{
          record: () => {
            return {
              id: `0${Date.now()}`,
            };
          },
        }}
        // request={async () => ({
        //   data: defaultData,
        //   total: 3,
        //   success: true,
        // })}
        onChange={setDataSource}
        columns={columns}
        rowKey="id"
      /> */}
      <Modal
        title="删除框提示?"
        visible={deleteVisit}
        onOk={async () => {
          console.log('----删除前的提示---', rowData);
          await delDriveParaLib({ id: rowData.id });
          actionRef.current.reload();
          setDeleteVisit(false);
        }}
        onCancel={() => {
          setDeleteVisit(false);
        }}
      >
        <p>确认删除设备信息</p>
      </Modal>
      <ToeUpload
        onCancel={() => {
          setUploadVisit(false);
        }}
        ref={uploadRef}
        onOk={async () => {
          const formData = new FormData();
          console.log(uploadRef.current.fileList, '文件测试---');
          uploadRef.current.fileList.map((file) => {
            formData.append('file', file);
          });
          // formData.append('file', 'jja');
          console.log(formData, '---formData--');
          await uploadLicenseExcel(formData);
          actionRef.current.reload();
          setUploadVisit(false);
        }}
        visible={uploadVisit}
        title="文件上传"
      />
    </PageHeaderWrapper>
  );
};

export default DriveParaLib;
